package com.mmall.service.impl;

import com.google.common.base.Splitter;
import com.google.common.collect.Lists;
import com.mmall.common.Const;
import com.mmall.common.ResponseCode;
import com.mmall.common.ServerResponse;
import com.mmall.dao.CartMapper;
import com.mmall.dao.ProductMapper;
import com.mmall.pojo.Cart;
import com.mmall.pojo.Product;
import com.mmall.service.ICartService;
import com.mmall.util.BigDecimalUtil;
import com.mmall.util.PropertiesUtil;
import com.mmall.vo.CartProductVo;
import com.mmall.vo.CartVo;

import org.apache.commons.collections.CollectionUtils;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;


import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

@Service("iCartService")
public class CartServiceImpl  implements ICartService{

    @Autowired
    private CartMapper cartMapper;

    @Autowired
    private ProductMapper productMapper;

    @Override
    public ServerResponse<CartVo> addCart(Integer userId, Integer count, Integer productId) {

        //1.判断参数是否正确
        if (count == null || productId == null){
            return ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getDesc());
        }
        //2.查询用户是id的和productaId判断是否已经加入购物车
       Cart cart = cartMapper.selectByUserIdAndProductId(userId,productId);

        //3.如果不存在,表示没有加入购物车,要加入购物车
        if (cart == null){
            Cart newcart = new Cart();
            newcart.setProductId(productId);
            newcart.setQuantity(count);
            newcart.setUserId(userId);
            newcart.setChecked(Const.Cart.CHECKED);  //表示已经加入购物车
            cartMapper.insert(newcart);
        }else {
            //4.已经加入购物车,就需要增加数量
            count = cart.getQuantity()+count;
            cart.setQuantity(count);
            cartMapper.updateByPrimaryKeySelective(cart);
        }

//        CartVo cartVo = this.getCartLimit(userId);
//        return ServerResponse.createBySuccess(cartVo);
        return  this.ListCart(userId) ;
    }

    @Override
    public ServerResponse updateCart(Integer userId, Integer count, Integer productId) {
        //判断差数是否错误
        if (count == null || productId == null){
            return ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getDesc());
        }
        //获得指定用户的购物车
        Cart cart = cartMapper.selectByUserIdAndProductId(userId, productId);
        if (cart != null){
            //购物车存在就更新数量
            cart.setQuantity(count);
        }

        //更新
        int cartCount =  cartMapper.updateByPrimaryKeySelective(cart);
        if (cartCount > 0){
            //封装

            return  ServerResponse.createBySuccess("更新购物车成功");
        }

        return  ServerResponse.createByErrorMessage("获取更新购物车数据失败");
    }

    @Override
    public ServerResponse<CartVo> delectCart(Integer userId,  String productIds) {

        //用guavu获得id的集合
        //List<String> productIdList = Splitter.on(",").splitToList(productIds);
        List<String> productIdList = Splitter.on(",").splitToList(productIds);

        if(CollectionUtils.isEmpty(productIdList)){
            return ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getDesc());
        }

        int cartCount = cartMapper.deleteByUserIdProductIds(userId, productIdList);

        if (cartCount > 0){
            //封装
//            CartVo cartVo = this.getCartLimit(userId);
//            return  ServerResponse.createBySuccess(cartVo);
            return  this.ListCart(userId) ;
        }

        return  ServerResponse.createByErrorMessage("获取删除购物车数据失败");
    }

    //展示购物车
    @Override
    public ServerResponse<CartVo> ListCart(Integer userId) {
        CartVo cartVo = this.getCartVoLimit(userId);
        return  ServerResponse.createBySuccess(cartVo);
    }

    @Override
    public ServerResponse<CartVo> updateAndcheckedALL(Integer userId, Integer productId,Integer checked) {

        int cartCount = cartMapper.updateAndchecked(userId,productId,checked);
        if (cartCount>0){
            return this.ListCart(userId);
        }
       return  ServerResponse.createByErrorMessage("差数错误,全选失败");
    }

    @Override
    public ServerResponse<CartVo> updateAndchecked(Integer userId, Integer productId, int checked) {
        int cartCount = cartMapper.updateAndchecked(userId,productId,checked);
        if (cartCount>0){
            return this.ListCart(userId);
        }
        return  ServerResponse.createByErrorMessage("差数错误,全反选失败");
    }

    @Override
    public ServerResponse<CartVo> OneupdateAndcheckedALL(Integer userId, Integer productId, int checked) {
        int cartCount = cartMapper.updateAndchecked(userId,productId,checked);
        if (cartCount>0){
            return this.ListCart(userId);
        }
        return  ServerResponse.createByErrorMessage("差数错误,单选失败");
    }

    @Override
    public ServerResponse<CartVo> OneupdateAndchecked(Integer userId, Integer productId, int checked) {
        int cartCount = cartMapper.updateAndchecked(userId,productId,checked);
        if (cartCount>0){
            return this.ListCart(userId);
        }
        return  ServerResponse.createByErrorMessage("差数错误,全单反选失败");
    }

    @Override
    public ServerResponse selcetCartAndProduct(Integer userId) {
        //判断用户id是否存在
        if (userId == null){
            return  ServerResponse.createBySuccess(0);
        }

       int cartCount = cartMapper.selcetCartAndProduct(userId);
        if (cartCount>0){
            return this.ListCart(userId);
        }
        return  ServerResponse.createBySuccess(0);
    }


//    private CartVo getCartLimit(Integer userId){
//        CartVo cartVo = new CartVo();
//        //查询指定用户下的所有购物车
//        List<Cart> cartList = cartMapper.selectCartAndUserId(userId);
//        List<CartProductVo> cartProductVoList = Lists.newArrayList();
//
//        //初始化一个总价格
//        BigDecimal cartTotalPrice = new BigDecimal("0");
//
//        if(CollectionUtils.isNotEmpty(cartList)){
//            for(Cart cartItem : cartList){
//                CartProductVo cartProductVo = new CartProductVo();
//                cartProductVo.setId(cartItem.getId());
//                cartProductVo.setUserId(userId);
//                cartProductVo.setProductId(cartItem.getProductId());
//
//                Product product = productMapper.selectByPrimaryKey(cartItem.getProductId());
//                if(product != null){
//                    cartProductVo.setProductMainImage(product.getMainImage());
//                    cartProductVo.setProductName(product.getName());
//                    cartProductVo.setProductSubtitle(product.getSubtitle());
//                    cartProductVo.setProductStatus(product.getStatus());
//                    cartProductVo.setProductPrice(product.getPrice());
//                    cartProductVo.setProductStock(product.getStock());
//                    //判断库存
//                    int buyLimitCount = 0;
//                    if(product.getStock() >= cartItem.getQuantity()){
//                        //库存充足的时候
//                        buyLimitCount = cartItem.getQuantity();
//                        cartProductVo.setLimitQuantity(Const.Cart.LIMIT_NUM_SUCCESS);
//                    }else{
//                        buyLimitCount = product.getStock();
//                        cartProductVo.setLimitQuantity(Const.Cart.LIMIT_NUM_FAIL);
//                        //购物车中更新有效库存
//                        Cart cartForQuantity = new Cart();
//                        cartForQuantity.setId(cartItem.getId());
//                        cartForQuantity.setQuantity(buyLimitCount);
//                        cartMapper.updateByPrimaryKeySelective(cartForQuantity);
//                    }
//                    cartProductVo.setQuantity(buyLimitCount);
//                    //计算总价
//                    cartProductVo.setProductTotalPrice(BigDecimalUtil.mul(product.getPrice().doubleValue(),cartProductVo.getQuantity()));
//                    cartProductVo.setProductChecked(cartItem.getChecked());
//                }
//
//                if(cartItem.getChecked() == Const.Cart.CHECKED){
//                    //如果已经勾选,增加到整个的购物车总价中
//                    cartTotalPrice = BigDecimalUtil.add(cartTotalPrice.doubleValue(),cartProductVo.getProductTotalPrice().doubleValue());
//                }
//                cartProductVoList.add(cartProductVo);
//            }
//        }
//        cartVo.setCreateTotalPrice(cartTotalPrice);
//        cartVo.setCartProductVos(cartProductVoList);
//        cartVo.setAllChecked(this.getAllCheckedStatus(userId));
//        cartVo.setImageHost(PropertiesUtil.getProperty("ftp.server.http.prefix"));
//
//        return cartVo;
//    }
//
//    private boolean getAllCheckedStatus(Integer userId){
//        if(userId == null){
//            return false;
//        }
//        return cartMapper.selectCartProductCheckedStatusByUserId(userId) == 0;
//
//    }

    private CartVo getCartVoLimit(Integer userId){
        CartVo cartVo = new CartVo();
        List<Cart> cartList = cartMapper.selectCartAndUserId(userId);
        List<CartProductVo> cartProductVoList = Lists.newArrayList();

        BigDecimal cartTotalPrice = new BigDecimal("0");

        if(CollectionUtils.isNotEmpty(cartList)){
            for(Cart cartItem : cartList){
                CartProductVo cartProductVo = new CartProductVo();
                cartProductVo.setId(cartItem.getId());
                cartProductVo.setUserId(userId);
                cartProductVo.setProductId(cartItem.getProductId());

                Product product = productMapper.selectByPrimaryKey(cartItem.getProductId());
                if(product != null){
                    cartProductVo.setProductMainImage(product.getMainImage());
                    cartProductVo.setProductName(product.getName());
                    cartProductVo.setProductSubtitle(product.getSubtitle());
                    cartProductVo.setProductStatus(product.getStatus());
                    cartProductVo.setProductPrice(product.getPrice());
                    cartProductVo.setProductStock(product.getStock());
                    //判断库存
                    int buyLimitCount = 0;
                    if(product.getStock() >= cartItem.getQuantity()){
                        //库存充足的时候
                        buyLimitCount = cartItem.getQuantity();
                        cartProductVo.setLimitQuantity(Const.Cart.LIMIT_NUM_SUCCESS);
                    }else{
                        buyLimitCount = product.getStock();
                        cartProductVo.setLimitQuantity(Const.Cart.LIMIT_NUM_FAIL);
                        //购物车中更新有效库存
                        Cart cartForQuantity = new Cart();
                        cartForQuantity.setId(cartItem.getId());
                        cartForQuantity.setQuantity(buyLimitCount);
                        cartMapper.updateByPrimaryKeySelective(cartForQuantity);
                    }
                    cartProductVo.setQuantity(buyLimitCount);
                    //计算总价
                    cartProductVo.setProductTotalPrice(BigDecimalUtil.mul(product.getPrice().doubleValue(),cartProductVo.getQuantity()));
                    cartProductVo.setProductChecked(cartItem.getChecked());
                }

                if(cartItem.getChecked() == Const.Cart.CHECKED){
                    if (cartProductVo.getProductTotalPrice().toString() != null){
                       // cartProductVo.getProductTotalPrice().doubleValue() == 0;
                        //cartTotalPrice = cartTotalPrice.doubleValue();
                        //如果已经勾选,增加到整个的购物车总价中
                        cartTotalPrice = BigDecimalUtil.add(cartTotalPrice.doubleValue(),cartProductVo.getProductTotalPrice().doubleValue());
                    }

                }
                cartProductVoList.add(cartProductVo);
            }
        }
        cartVo.setCartTotalPrice(cartTotalPrice);
        cartVo.setCartProductVoList(cartProductVoList);
        cartVo.setAllChecked(this.getAllCheckedStatus(userId));
        cartVo.setImageHost(PropertiesUtil.getProperty("ftp.server.http.prefix"));

        return cartVo;
    }

    private boolean getAllCheckedStatus(Integer userId) {
        if (userId == null) {
            return false;
        }
        return cartMapper.selectCartProductCheckedStatusByUserId(userId) == 0;
    }



}
